package com.ty.springbootshiro.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.ty.springbootshiro.entity.User;
import com.ty.springbootshiro.mapper.UserMapper;
import com.ty.springbootshiro.service.UserService;
import jakarta.annotation.Resource;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * UserServiceImpl
 *
 * @aurhor Administrator  whs
 * @since 2024/9/4
 */
@Service()
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {
    @Resource
    public UserMapper userMapper;

    @Override
    public User login(String usrName, String usrPassword) {
        return userMapper.login(usrName, usrPassword);
    }

    /**
     * 根据用户名和角色ID分页查询用户数据
     *
     * @Cacheable 首先查缓存有就返回，没有就执行方法，方法返回不为空添加缓存
     * value: 缓存名称，可以多个
     * key: 缓存的键值
     * keyGenerator = "keyGenerator": 缓存的key自动生成
     * condition: 满足条件的调用，结果才会被缓存（不指定时相当于true-缓存）
     * unless: 不合适的返回，结果不缓存（不指定时相当于false-缓存）
     * 总结: 当condition=false一定不缓存；当condition=true且unless=true不缓存；当condition=true且unless=false缓存
     */
    @Override
    // @Cacheable(value = "userPage", keyGenerator = "keyGenerator") // 每次都是新的page对象，无法实现缓存
    @Cacheable(value = "user", key = "'page:' + #page.current + '-' + #page.size + '-' + #usrName + '-' + #roleId", condition = "#page.current!=null and #page.size!=null", unless = "#result==null")
    public Page<User> userPage(Long roleId, String usrName, Page<User> page) {
        return userMapper.userPage(roleId, usrName, page);
    }

    /**
     * 根据用户名查询用户是否存在（排除指定ID）
     *
     * @param usrName
     * @param usrId
     */
    @Override
    public User getByUsrNameExceptUsrId(String usrName, Long usrId) {
        return userMapper.getByUsrNameExceptUsrId(usrName, usrId);
    }

    /**
     * 根据用户名查找用户及对应的角色
     *
     * @param usrName
     * @return
     * @Cacheable 首先查缓存有就返回，没有就执行方法，方法返回不为空添加缓存
     * value: 缓存名称，可以多个
     * key: 缓存的键值
     * condition: 满足条件的调用，结果才会被缓存（不指定时相当于true-缓存）
     * unless: 不合适的返回，结果不缓存（不指定时相当于false-缓存）
     * 总结: 当condition=false一定不缓存；当condition=true且unless=true不缓存；当condition=true且unless=false缓存
     */
    @Override
    @Cacheable(value = "user", key = "'usrName:' + #usrName", condition = "#usrName!=null", unless = "#result==null")
    public User getUserByName(String usrName) {
        return userMapper.getUserByName(usrName);
    }

    /**
     * 保存或修改用户（如果有主键ID则修改，没有则保存）
     *
     * @param user 用户
     * @return
     * @CachePut 首先执行方法体，执行完毕后根据参数设置进行缓存覆盖
     * value: 缓存名称
     * key: 缓存的键值
     * condition: 满足条件的调用，结果才会被缓存（不指定时相当于true-缓存）
     * unless: 不合适的返回，结果不缓存（不指定时相当于false-缓存）
     * 总结: 当condition=false一定不缓存；当condition=true且unless=true不缓存；当condition=true且unless=false缓存
     */
    @Override
    @CachePut(value = "user", key = "'usrId:' + #user.usrId", condition = "#user!=null", unless = "#result==null")
    @CacheEvict(value = "user", allEntries = true)
    public int add(User user) {
        return userMapper.add(user);
    }

    @Override
    public int del(Long usrId) {
        return userMapper.del(usrId);
    }

    /**
     * 通过用户ID获取用户对象
     *
     * @param usrId
     * @return
     */
    @Override
    @Cacheable(value = "user", key = "'usrId:' + #usrId")
    public User getUser(Long usrId) {
        return userMapper.getUser(usrId);
    }

    @Override
    public boolean deleteUser(Long usrId) {
        return userMapper.deleteUser(usrId);
    }

    @Override
    public int upd(User user) {
        return userMapper.upd(user);
    }

    @Override
    public String encryptPassword(Object plaintextPassword) throws IllegalAccessException {
        String salt = "离别情诗雨";
        Md5Hash md5Hash = new Md5Hash(plaintextPassword,salt,520);
        System.out.println("md5Hash ----- > " + md5Hash.toString());

        return md5Hash.toString();
    }

//    /**
//     * 登录功能
//     *
//     * @param usrName
//     * @param usrPassword
//     */
//    @Override
//    public User login(String usrName, String usrPassword) {
//        QueryWrapper<User> qw = new QueryWrapper<>();
//        qw.eq("usr_name", usrName);
//        qw.eq("usr_password", usrPassword);
//        User user = userMapper.selectOne(qw);
//        return user;
//    }
//
//
//
//    @Cacheable(value = "user" , keyGenerator = "keyGenerator")
//    public User getCacheableUser(int usrId){
//        return userMapper.selectById(usrId);
//    }
//
//
//
//
//    /**
//     * 添加用户
//     *
//     * @param user
//     * @return
//     */
//    @Override
//    public int addUser(User user) {
//        return userMapper.insert(user);
//    }
//
//
//    /**
//     * 删除用户
//     *
//     * @param
//     * @return
//     */
//    @Override
//    public int deleteUser(Long usrId) {
//        return userMapper.deleteById(usrId);
//    }
//
//    /**
//     * 修改用户
//     *
//     * @param user
//     * @return
//     */
//    @Override
//    public int updateUser(User user) {
//        return userMapper.updateById(user);
//    }
//
//    /**
//     * 根据id查询用户
//     *
//     * @param usrId
//     * @return
//     */
//    @Override
//    public User getUser(Long usrId) {
//        return userMapper.selectOne(new QueryWrapper<User>().eq("usr_id", usrId));
//    }
//
//    /**
//     * 查询所有用户
//     *
//     * @return
//     */
//    @Override
//    public List<User> findAllUsers() {
//        return userMapper.selectList(null);
//    }
}